package com.cfjjc.gz.usraccount.service;

import java.util.List;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.cfjjc.gz.common.consts.SystemConst;
import com.cfjjc.gz.common.consts.TradeInfoConst;
import com.cfjjc.gz.common.consts.TypeValueConst;
import com.cfjjc.gz.common.dao.DefaultDAO;
import com.cfjjc.gz.common.exception.OTSException;
import com.cfjjc.gz.common.service.BaseService;
import com.cfjjc.gz.common.util.DateTimeUtil;
import com.cfjjc.gz.common.util.RandomGUID;
import com.cfjjc.gz.common.util.StringUtil;
import com.cfjjc.gz.common.util.paged.PagedList;
import com.cfjjc.gz.usraccount.vo.A_USR_GRPVO;
import com.cfjjc.gz.usraccount.vo.A_USR_USRGRPVO;

/**
 * 
 * 说明：用户组信息表 业务逻辑层对象
 * 
 * @author liuxun
 * @since 2012-03-06
 * @version 1.0
 */
@Service
@Transactional(rollbackFor = Throwable.class)
public class A_USR_GRPService extends BaseService{

	/**
	 * logger对象
	 */
	private static final Logger logger = Logger
			.getLogger(A_USR_GRPService.class);

	@Autowired
	private DefaultDAO dao;

	@Autowired
	private A_USR_USRGRPService a_USR_USRGRPService;

	// 要访问的dao的命名空间
	private String namespace = "A_USR_GRP";

	public A_USR_GRPService() {
		super();
	}

	/**
	 * 仅查询单条用户组信息表的详细信息
	 */
	public A_USR_GRPVO queryA_USR_GRP(A_USR_GRPVO param) throws OTSException {
		return (A_USR_GRPVO) dao.queryObject(param, this.namespace);
	}

	/**
	 * 根据条件检索用户组信息表，返回分页结果
	 */
	public void queryA_USR_GRPs(A_USR_GRPVO param, PagedList records)
			throws OTSException {
		dao.queryPagedList(param, records, this.namespace);
	}

	/**
	 * 根据条件检索用户组信息表，返回所有结果
	 */
	public List<A_USR_GRPVO> queryA_USR_GRPList(A_USR_GRPVO param)
			throws OTSException {
		return dao.queryList(param, this.namespace);
	}

	/**
	 * 增加用户组信息表
	 */
	public void doInsertA_USR_GRP(A_USR_GRPVO param) throws OTSException {

		param.setKey(RandomGUID.getRandomGuid());
		param.setNode_id(SystemConst.NODE_ID); // TODO 临时写死
		param.setCreate_at(DateTimeUtil.getDateTime());

		// 录入前的校验
		_checkFields(param, SystemConst.OPERATION_TYPE_NEW);

		// 校验用户组代码是否重复
		A_USR_GRPVO query = new A_USR_GRPVO();
		query.setUsr_grp_code(param.getUsr_grp_code());
		query.setUsr_grp_status(TypeValueConst.USR_GRP_STATUS_DELETE);
		query.setContainsDeleted(SystemConst.NO_CONST);
		A_USR_GRPVO res = (A_USR_GRPVO) this.queryA_USR_GRP(query);

		if (res != null) {
			throw new OTSException("当前用户组代码：" + param.getUsr_grp_code()
					+ " 已存在!");
		}
		
		// 校验用户组名称是否重复
		query = new A_USR_GRPVO();
		query.setUsr_grp_status(TypeValueConst.USR_GRP_STATUS_DELETE);
		query.setContainsDeleted(SystemConst.NO_CONST);
		query.setUsr_grp_name(param.getUsr_grp_name());
		A_USR_GRPVO isRepeat = (A_USR_GRPVO) this.queryA_USR_GRP(query);

		if (isRepeat != null) {
			throw new OTSException("当前用户组名称：" + param.getUsr_grp_name()
					+ " 已存在!");
		}

		dao.insert(param, this.namespace);
		if (logger.isDebugEnabled()) {
			logger.debug("增加一条用户组信息表记录:" + param);
		}
		
	//	insertTradeLog(TradeInfoConst.TRADE_ADD_USR_GRP, param.getUsr_grp_name(), param);
	}

	/**
	 * 修改用户组信息表
	 */
	public void doUpdateA_USR_GRP(A_USR_GRPVO param) throws OTSException {

		A_USR_GRPVO query = new A_USR_GRPVO();
		query.setUsr_grp_id(param.getUsr_grp_id());
		A_USR_GRPVO res = (A_USR_GRPVO) this.queryA_USR_GRP(query);

		if (res == null) {
			throw new OTSException("要操作的记录不存在,请刷新页面后重试或联系管理员！");
		}
		
		if(TypeValueConst.USR_GRP_STATUS_DELETE.equals(res.getUsr_grp_status())){
			throw new OTSException("已删除的用户组不允许修改操作！");
		}
		
		query = new A_USR_GRPVO();
		query.setUsr_grp_name(param.getUsr_grp_name());
		query.setUsr_grp_status(TypeValueConst.USR_GRP_STATUS_DELETE);
		query.setContainsDeleted(SystemConst.NO_CONST);
		A_USR_GRPVO isRepeat = (A_USR_GRPVO) this.queryA_USR_GRP(query);
		
		if (isRepeat != null && !isRepeat.getUsr_grp_id().equals(res.getUsr_grp_id())) {
			throw new OTSException("当前用户组： " + param.getUsr_grp_name() + "已存在！");
		}
		param.setUpdate_at(DateTimeUtil.getDateTime());
		// 修改前的校验
		_checkFields(param, SystemConst.OPERATION_TYPE_MODIFY);
		dao.update(param, this.namespace);
		if (logger.isDebugEnabled()) {
			logger.debug("修改用户组信息表:" + param);
		}
		
	//	insertTradeLog(TradeInfoConst.TRADE_MODIFY_USR_GRP, param.getUsr_grp_name(), param);
	}

	/**
	 * 删除用户组信息表
	 */
	public void doDeleteA_USR_GRP(A_USR_GRPVO param) throws OTSException {
		// 删除前的校验
		_checkFields(param, SystemConst.OPERATION_TYPE_DELETE);
		
		A_USR_GRPVO query = new A_USR_GRPVO();
		query.setUsr_grp_id(param.getUsr_grp_id());
		A_USR_GRPVO res = this.queryA_USR_GRP(query);

		if (res == null) {
			throw new OTSException("要操作的记录不存在，请刷新页面后重试或联系管理员！");
		}

		// 若用户组下存在用户，不能删除该用户组
		String org_id = res.getUsr_grp_id();
		A_USR_USRGRPVO queryUsr = new A_USR_USRGRPVO();
		queryUsr.setUsr_grp_id(org_id);
		List rsUsr = this.a_USR_USRGRPService.queryA_USR_USRGRPList(queryUsr);

		if (!rsUsr.isEmpty()) {
			throw new OTSException("当前用户组下存在用户，不能删除该用户组！");
		}

		res.setUpdate_by(param.getUpdate_by());
		res.setUpdate_at(DateTimeUtil.getDateTime());
		res.setUsr_grp_status(TypeValueConst.USR_GRP_STATUS_DELETE);
		dao.update(res, this.namespace);
		if (logger.isDebugEnabled()) {
			logger.debug("删除用户组信息表:" + res);
		}
		
	//	insertTradeLog(TradeInfoConst.TRADE_DEL_USR_GRP, res.getUsr_grp_name(), res);
	}

	/** 以下为私有方法.私有方法应以下划线"_"开头 */
	/**
	 * 对当前的操作对象进行字段级的校验<br>
	 * 
	 * @param param
	 *            待操作的vo对象
	 * @param opeType
	 *            操作类型,见SystemConst中定义的常数
	 * 
	 * @see com.mofit.fs.yhbs.common.SystemConst
	 */
	private void _checkFields(A_USR_GRPVO param, int opeType)
			throws OTSException {
		if (logger.isDebugEnabled()) {
			logger.debug("对待保存的对象进行字段校验,操作类型opeType=" + opeType);
		}
		/*
		 * 除操作类型为insert外,主键字段不能为空
		 */
		if (opeType != SystemConst.OPERATION_TYPE_NEW) {

			if (param.getUsr_grp_id() == null
					|| "".equals(String.valueOf(param.getUsr_grp_id()))) {
				throw new OTSException("用户组ID不能为空！");
			}

		}
		/*
		 * 对于操作类型为insert,非主键字段中不允许null的字段不能为空
		 */
		if (opeType == SystemConst.OPERATION_TYPE_NEW || opeType == SystemConst.OPERATION_TYPE_MODIFY) {

			if (param.getUsr_grp_code() == null
					|| "".equals(String.valueOf(param.getUsr_grp_code()))) {
				throw new OTSException("用户组代码不能为空！");
			}

			if (param.getUsr_grp_name() == null
					|| "".equals(String.valueOf(param.getUsr_grp_name()))) {
				throw new OTSException("用户组名称不能为空！");
			}

			if (param.getUsr_grp_type() == null
					|| "".equals(String.valueOf(param.getUsr_grp_type()))) {
				throw new OTSException("用户组类型不能为空！");
			}

			if (param.getUsr_grp_status() == null
					|| "".equals(String.valueOf(param.getUsr_grp_status()))) {
				throw new OTSException("用户组状态不能为空！");
			}

			if (param.getNode_id() == null
					|| "".equals(String.valueOf(param.getNode_id()))) {
				throw new OTSException("节点ID不能为空！");
			}

		}

		/*
		 * 对于操作类型为insert或update,字段长度不能超过表中字段长度
		 */
		if (opeType == SystemConst.OPERATION_TYPE_NEW
				|| opeType == SystemConst.OPERATION_TYPE_MODIFY) {

			if (StringUtil.getLength(param.getUsr_grp_code()) > 50) {
				throw new OTSException("用户组代码内容长度不能大于50位,请检查！");
			}

			if (StringUtil.getLength(param.getUsr_grp_name()) > 50) {
				throw new OTSException("用户组名称内容长度不能大于50位,请检查！");
			}

			if (StringUtil.getLength(param.getUsr_grp_type()) > 50) {
				throw new OTSException("用户组类型内容长度不能大于50位,请检查！");
			}

			if (StringUtil.getLength(param.getUsr_grp_status()) > 50) {
				throw new OTSException("用户组状态内容长度不能大于50位,请检查！");
			}

			if (StringUtil.getLength(param.getUsr_grp_desc()) > 255) {
				throw new OTSException("描述内容长度不能大于255位,请检查！");
			}

			if (StringUtil.getLength(param.getNode_id()) > 50) {
				throw new OTSException("节点ID内容长度不能大于50位,请检查！");
			}

		}

		if (logger.isDebugEnabled()) {
			logger.debug("字段校验通过");
		}
	}
}